package homebudget;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.NumberFormat;
import java.util.Date;
import java.util.LinkedList;
import javax.swing.text.StyledEditorKit.BoldAction;

/**
 *Funkcje służące do obsługi bazy danych
 *
 * @author lukasz burczak
 * @version 1.1
 *
 */
public class DataBaseMySql {
    private Connection connection;


    private Statement statemnet;
    private ResultSet rs;
    private String connectionString;

    /**
     * Konstruktor tworzy obiekt Connection i łaczy sie z bazą
     * @param connectionString ConnectionString do bazy
     * w formie adres_serwera:port//nazwa_bazy
     */
    public DataBaseMySql(){}

    public DataBaseMySql(String connectionString){
        this.connectionString = connectionString;
        this.connection = null;
        //ładowanie sterownika bazy
        try{
            Class.forName("com.mysql.jdbc.Driver");
        }catch(ClassNotFoundException e){
            System.out.println("Blad przy ladowaniu steronika bazy: "+e);
            System.exit(-1);
        }
        //łaczenie sie z bazą
        try{
            connection = DriverManager.getConnection("jdbc:mysql://"+this.connectionString, HomeBudgetApp.getLogin(), HomeBudgetApp.getHaslo());
        }catch(SQLException e){
            System.out.println("Nie mozna nawiazać polaczenia z baza danych "+e);
            System.exit(-1);
        }
        System.out.println("Polaczenie nawiazano z "+connectionString);
    }

    /**
     * Funkcja służąca do kończenia połączenia z bazą
     */
    public void close(){
        try{
            connection.close();
        }catch(SQLException e){
            System.out.println("Blad przy zamykaniu");
            System.exit(-1);
        }
        System.out.println("Polaczenie zamkniete z "+this.connectionString);

    }

     public Connection getConnection() {
        return connection;
    }
    //funkcje do obsługi bazy danych BUDZET


     public boolean stworzBaze(){
         
         try{
             connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/",HomeBudgetApp.getLogin(),HomeBudgetApp.getHaslo());
             statemnet = connection.createStatement();

             String query = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = 'budzet'";
             rs = statemnet.executeQuery(query);

             boolean jestBaza = false;

             while(rs.next()){
                jestBaza=true;
                    
             }
             if(!jestBaza)
                 utworzTabele("schema.sql");

             
             
         }catch(SQLException e){
             System.err.println("Bład przy połaczeniu");
             return false;
         }
         return true;
     }

     public void utworzTabele(String filename){
        String s = new String();
        StringBuffer sb = new StringBuffer();

         try
        {
            FileReader fr = new FileReader(new File(filename));
            // be sure to not have line starting with "--" or "/*" or any other non aplhabetical character
            BufferedReader br = new BufferedReader(fr);
            while((s = br.readLine()) != null)
            {
                sb.append(s);
            }
            br.close();

            // here is our splitter ! We use ";" as a delimiter for each request
            // then we are sure to have well formed statements
            String[] inst = sb.toString().split(";");

            statemnet = connection.createStatement();

            for(int i = 0; i<inst.length; i++)
            {
                // we ensure that there is no spaces before or after the request string
                // in order to not execute empty statements
                if(!inst[i].trim().equals(""))
                {
                    
                    statemnet.executeUpdate(inst[i]);
                    System.out.println(">>"+inst[i]);
                }
            }

        }
        catch(Exception e)
        {
            System.out.println("*** Error : "+e.toString());
            System.out.println("*** ");
            System.out.println("*** Error : ");
            e.printStackTrace();
            System.out.println("################################################");
            System.out.println(sb.toString());
        }
     }



    /**
     * Funkcja służąca do dodawania sklepu
     *
     * @param nazwa Nazwa sklepu który ma zostać dodany
     * @return zwraca wartość "True" w przypadku dodania  do bazy
     * lub "False" gdy produkt znajduje się juz w bazie.
     *
     */

   public Boolean dodajSklep(String nazwa){

        //zapytanie sprawdzające czy dana nazwa sklepu juz występuje w bazie
        String query = "SELECT count(*) as liczba from sklep where nazwa='"+nazwa+"'";

        try{
            statemnet = connection.createStatement();
            rs = statemnet.executeQuery(query);
            String liczba="";
            
            while(rs.next()){
                liczba =  rs.getString("liczba");
            }
            //jezeli sklep juz występuje w bazie
            if(!liczba.equals("0"))
                return false;
            else{
                query = "INSERT INTO sklep(nazwa) VALUE('"+nazwa+"')";
                statemnet.executeUpdate(query);
            }
        }catch (SQLException e) {
            System.err.println("Bład: "+e);
        }
        return true;
    }

   /**
    * Funkcja usuwa z tabeli "SKLEP" sklep o podanej w parametrze nazwie
    *
    * @param nazwa Nazwa sklepu do usuniecia
    * @return
    */

   public Boolean usunSklep(String nazwa){

       String query = "DELETE FROM sklep WHERE nazwa='"+nazwa+"'";

       try{
           statemnet = connection.createStatement();
           statemnet.executeUpdate(query);
       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }
       return true;
   }


/**
 * Funkcja edytuje nazwę sklepu
 *
 * @param staraN Stara nazwa sklepu
 * @param nowaN  Nowa nazwa sklepu
 * @return
 */
  public Boolean edytujSklep(String staraN,String nowaN){
      String query = "UPDATE sklep SET nazwa='"+nowaN+"' WHERE nazwa='"+staraN+"'";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
      return true;
  }

 public LinkedList<String> listaSklep(){
       LinkedList<String> lista = new LinkedList<String>();

       String query = "SELECT nazwa from sklep where nazwa<>'Brak'";

       try{
           statemnet = connection.createStatement();
           rs = statemnet.executeQuery(query);

           while(rs.next()){
               lista.add(rs.getString("nazwa"));
           }

       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }

       return lista;

    }

   /**
    * Funkcja dodająca kategorie produktu do bazy
    *
    * @param nazwa Nazwa kategorii produktu, który chcemy dodać
    * @return zwraca wartość "True" w przypadku dodania lub "FALSE"
    * gdy kategoria juz znajduje sie w bazie.
    */

   public Boolean dodajKategorieProduktu(String nazwa){

        //zapytanie sprawdzające czy dana nazwa kategorii występuje juz występuje w bazie
        String query = "SELECT count(*) as liczba from katprodukt where nazwa='"+nazwa+"'";

        try{
            statemnet = connection.createStatement();
            rs = statemnet.executeQuery(query);
            String liczba="";

            while(rs.next()){
                liczba =  rs.getString("liczba");
            }
            //jezeli nazwa kategorii juz występuje juz występuje w bazie
            if(!liczba.equals("0"))
                return false;
            else{
                query = "INSERT INTO katprodukt(nazwa) VALUE('"+nazwa+"')";
                statemnet.executeUpdate(query);
            }
        }catch (SQLException e) {
            System.err.println("Bład "+e);
        }
        return true;
   }



   /**
    * Funkcja usuwająca z tabeli "KATPRODUKT" kategorie produktów
    *
    * @param nazwa
    */

   public void usunKategorieProduktu(String nazwa){
       String query = "DELETE FROM katprodukt where nazwa='"+nazwa+"'";
       try{
           statemnet = connection.createStatement();
           statemnet.executeUpdate(query);
       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }
   }


    public Boolean edytujKategorieProduktu(String staraN,String nowaN){
      String query = "UPDATE katprodukt SET nazwa='"+nowaN+"' WHERE nazwa='"+staraN+"'";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
      return true;
  }
   /**
    * Funkcja dodaje produkt do tabeli "PRODUKT"
    *
    * @param nazwa Nazwa produktu
    * @param idSklep ID Sklepu
    * @param idKatProdukt ID Kategorii produktu np. Jedzenie
    * @param cena Cena produktu
    * @return Funkcja zwraca ID nowowstawionego rekordu gdy ten nie znajduje sie
    * w bazie, w przeciwnym wypadku zwraca ID istniejącego produktu
    */
   public int dodajProdukt(String nazwa,int idSklep,int idKatProdukt,double  cena,int idBudzet){

        //zapytanie sprawdzające czy dany produkt z danego sklepu i o danej kategorii juz występuje w bazie
        String query = "SELECT produkt.id_produkt, count(*) as liczba from produkt,wydatek_produkt wp,wydatek w,budzetwydatek bw,budzet b where produkt.nazwa='"+nazwa+"' and id_sklep="+idSklep+""
                + " and id_kat_produkt="+idKatProdukt+" and cena="+cena+" and produkt.id_produkt=wp.id_produkt "
                + "and wp.id_wydatek=w.id_wydatek and w.id_wydatek=bw.id_wydatek "
                + "and bw.id_budzet = b.id_budzet and b.id_budzet="+idBudzet+"";

        String liczba="";
        int id_produkt=0;

        try{
            statemnet = connection.createStatement();
            rs = statemnet.executeQuery(query);
            

            while(rs.next()){
                liczba =  rs.getString("liczba");
                id_produkt = rs.getInt("id_produkt");
            }
            //jezeli dany produkt występuje juz występuje w bazie
            if(!liczba.equals("0"))
                //zostaje zwrócony ID juz isniejącego wiersza
                return id_produkt;
            else{
                query = "INSERT INTO produkt(nazwa,id_sklep,cena,id_kat_produkt)"
                        + " VALUE('"+nazwa+"',"+idSklep+","+cena+","+idKatProdukt+")";
                statemnet.executeUpdate(query);

                //pobieranie ID ostatnio wstawionego rekordu
                query = "SELECT last_insert_id() as ID from produkt";
                rs = statemnet.executeQuery(query);

                while(rs.next()){
                    id_produkt = rs.getInt("ID");
                }

            }
        }catch (SQLException e) {
            System.err.println("Bład: "+e);
        }
        return id_produkt;
   }

   /**
    * Funkcja usuwa produkt z tabeli "PRODUKT"
    * 
    * @param nazwa Nazwa produktu
    * @param idSklep ID Sklepu
    * @param idKatProdukt ID Kategori Produktu
    * @param cena Cena produktu
    */

   public void usunProdukt(String nazwa,int idSklep,int idKatProdukt,double  cena,int idBudzet){
       String query = "DELETE FROM produkt p,wydatek_produkt wp,wydatek w,budzetwydatek bw,budzet b where p.nazwa='"+nazwa+"' and id_sklep="+idSklep+""
                + " and p.id_kat_produkt="+idKatProdukt+" and p.cena="+cena+" "
                + "and p.id_produkt=wp.id_produkt "
                + "and wp.id_wydatek=w.id_wydatek and w.id_wydatek=bw.id_wydatek "
                + "and bw.id_budzet = b.id_budzet and b.id_budzet="+idBudzet+"";
        try{
           statemnet = connection.createStatement();
           statemnet.executeUpdate(query);
       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }
   }

   /**
    * Funkcja zwraca liste nazw kategorii z tabeli "KATPRZYCHOD"
    *
    * @return lista linkedList
    */
   public LinkedList<String> listaKategoriaPrzychod(){
       LinkedList<String> lista = new LinkedList<String>();

       String query = "SELECT nazwa from katprzychod where nazwa<>'Brak'";

       try{
           statemnet = connection.createStatement();
           rs = statemnet.executeQuery(query);

           while(rs.next()){
               lista.add(rs.getString("nazwa"));
           }

       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }

       return lista;

    }

   /**
    * Funkcja zwraca liste nazw kategorii z tabeli "KATWYDATEK"
    * 
    * @return lista linkedList
    */

   public LinkedList<String> listaKategoriaWydatek(){
       LinkedList<String> lista = new LinkedList<String>();

       String query = "SELECT nazwa from katwydatek where nazwa<>'Brak'";

       try{
           statemnet = connection.createStatement();
           rs = statemnet.executeQuery(query);

           while(rs.next()){
               lista.add(rs.getString("nazwa"));
           }

       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }

       return lista;

    }

   public LinkedList<String> listaKategoriaProdukt(){
       LinkedList<String> lista = new LinkedList<String>();

           String query = "SELECT nazwa FROM katprodukt where nazwa<>'Brak'";

       try{
           statemnet = connection.createStatement();
           rs = statemnet.executeQuery(query);

           while(rs.next()){
               lista.add(rs.getString("nazwa"));
           }

       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }

       return lista;

    }
   /**
    * Funkcja zwraca liste produktów należacych do podanej kategorii
    *
    * @param nazwaKategorii Nazwa kategorii z której maja być zwrócone produkty
    * @return Zwaraca obiekt LinkedList zawierający listę produktów
    */

   public LinkedList<String> listaProdukt(String nazwaKategorii,int idBudzet){

       String query = "SELECT DISTINCT p.nazwa as nazwaProdukt FROM produkt p, katprodukt kp,wydatek_produkt wp,wydatek w,budzetwydatek bw,budzet b"
               + " WHERE p.id_kat_produkt = kp.id_kat_produkt and kp.nazwa='"+nazwaKategorii+"'"
                + "and p.id_produkt=wp.id_produkt "
                + "and wp.id_wydatek=w.id_wydatek and w.id_wydatek=bw.id_wydatek "
                + "and bw.id_budzet = b.id_budzet and b.id_budzet="+idBudzet+"";
       LinkedList<String> lista = new LinkedList<String>();
       try{
           statemnet = connection.createStatement();
           rs = statemnet.executeQuery(query);

           while(rs.next()){
               lista.add(rs.getString("nazwaProdukt"));
           }

       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }

       return lista;
   }
    
/**
 * Funkcja dodaje wydatek do tabeli "WYDATEK" i zwraca ID wstawionego wiersza
 * @param nazwa nazwa wydatku
 * @param idKatWydatek id kategori wydatku np. jedzenie
 * @param wartosc wartość double wydatku np. 9.99
 * @param data Data wydatku
 * @return funkcja zwraca ID rekordu nowo wstawionego wiersza przez instrukcje INSERT czyli ID wydatku
 */
  public int dodajWydatek(String nazwa,int idKatWydatek,double wartosc,String data){

        String query = "INSERT INTO wydatek(nazwa,id_kat_wydatek,data_wydatek,wartosc)"
                + " VALUE('"+nazwa+"',"+idKatWydatek+",'"+data+"',"+wartosc+")";
        int id_wydatek=0;
        try{
            statemnet = connection.createStatement();
            statemnet.executeUpdate(query);

            //pobieranie ID ostatnio wstawionego rekordu
                query = "SELECT last_insert_id() as ID from wydatek";
                rs = statemnet.executeQuery(query);

                while(rs.next()){
                    id_wydatek = rs.getInt("ID");
                }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }

        return id_wydatek;
    }
  /**
   * Funkcja usuwająca wydatek z tabeli "WYDATEK"
   *
   * @param id_wydatek ID wydatku, który chcemy usunąć
   */
 public void usunWydatek(int id_wydatek){
     String query = "DELETE FROM wydatek WHERE id_wydatke="+id_wydatek;

      try{
           statemnet = connection.createStatement();
           statemnet.executeUpdate(query);
       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }
 }


  /**
   * Funkcja dodaje produkt do określonego wydatku. 
   *
   * @param idWydatku ID wydatku do którego chcemy dodać produkt
   * @param idProduktu ID produktu, który chcemy dodac do wydatku
   * @param ilosc Ilosc produktu która bedzie dodana do wydatku np. 1 torebka rzeżuchy lub 0.20 kg boczku
   * @param koszt ilosc x cena produktu
   */
  public boolean dodajProduktDoWydatku(int idWydatku,int idProduktu,double ilosc,double koszt){
      String query = "INSERT INTO wydatek_produkt(id_wydatek,id_produkt,ilosc,koszt) "
              + "VALUES("+idWydatku+","+idProduktu+","+ilosc+","+koszt+")";
      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);

      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
      return true;
  }

  /**
   * Funkcja dodaje kategorie do tabeli "KATWYDATEK"
   *
   * @param nazwa Nazwa kategorii
   * @return Funkcja zwraca wartość TRUE w przypadku gdy doda wpis do bazy, FALSE gdy go niedoda np. gdy wpis juz istnieje
   */


  public Boolean dodajKategorieWydatku(String nazwa){
      //zapytanie sprawdzające czy dana nazwa kategorii juz występuje w bazie
        String query = "SELECT count(*) as liczba from katwydatek where nazwa='"+nazwa+"'";

        try{
            statemnet = connection.createStatement();
            rs = statemnet.executeQuery(query);
            String liczba="";

            while(rs.next()){
                liczba =  rs.getString("liczba");
            }
            //jezeli nazwa kategorii juz występuje juz występuje w bazie
            if(!liczba.equals("0"))
                return false;
            else{
                query = "INSERT INTO katwydatek(nazwa) VALUE('"+nazwa+"')";
                statemnet.executeUpdate(query);
            }
        }catch (SQLException e) {
            System.err.println("Bład "+e);
        }
        return true;
  }

  /**
   * Funkcja usuwająca z tabeli "KATWYDATEK" kategorie wydatku
   *
   * @param nazwa Nazwa kategorii do usuniecia
   */

  public void usunKategorieWydatku(String nazwa){
      String query = "DELETE FROM katwydatek where nazwa='"+nazwa+"'";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
  }
/**
 * Funkcja edytuje nazwet kategorii wydatku
 *
 * @param staraN Stara nazwa kategorii
 * @param nowaN  Nowa nazwa kategorii
 * @return
 */
  public Boolean edytujKategorieWydatku(String staraN,String nowaN){
      String query = "UPDATE katwydatek SET nazwa='"+nowaN+"' WHERE nazwa='"+staraN+"'";
      
      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
      return true;
  }

  /**
   * Funkcja dodaje nazwę nowego budzetu do tabeli "BUDZET"
   *
   * @param nazwa Nazwa nowego budzetu
   * @return Zwraca wartośc TRUE jezeli doda do bazy, w przeciwnym wypadku zwraca wartośc FALSE np. gdy dana nazwa znajduje sie juz w bazie
   */

  public int dodajBudzet(String nazwa){
       //zapytanie sprawdzające czy dana nazwa budzetu juz występuje w bazie
        String query = "SELECT count(*) as liczba from budzet where nazwa='"+nazwa+"'";
        int ID=0;
        try{
            statemnet = connection.createStatement();
            rs = statemnet.executeQuery(query);

            int liczba=0;
            while(rs.next()){
                liczba = rs.getInt("liczba");
            }

            if(liczba!=0){
                return -1;
            }else
            {
                query = "INSERT INTO budzet(nazwa) VALUE('"+nazwa+"')";
                statemnet.executeUpdate(query);

                //pobieranie ID ostatnio wstawionego rekordu
                query = "SELECT last_insert_id() as ID from produkt";
                rs = statemnet.executeQuery(query);
                while(rs.next()){
                    ID=rs.getInt("ID");
                }
            }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }
        return ID;
  }

  public void usunBudzet(String nazwa){
      String query = "DELETE FROM budzet where nazwa='"+nazwa+"'";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
  }

  public LinkedList<String> listaBudzet(){
       LinkedList<String> lista = new LinkedList<String>();

           String query = "SELECT nazwa FROM budzet";

       try{
           statemnet = connection.createStatement();
           rs = statemnet.executeQuery(query);

           while(rs.next()){
               lista.add(rs.getString("nazwa"));
           }

       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }

       return lista;

    }

  /**
   * Funkcja dodaje rekort do tabeli "BUDZETWYDATEK"
   *
   * @param id_Budzet ID budzetu do ktorego chcemy dodać wydatek
   * @param id_wydatek ID wydatku
   */
  public void dodajBudzetWydatek(int id_Budzet,int id_wydatek){
      String query = "INSERT INTO budzetwydatek(id_budzet,id_wydatek) VALUES("+id_Budzet+","+id_wydatek+")";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }

  }
  /**
   * Funkcja usuwa rekort z tabeli "BUDZETWYDATEK"
   *
   * @param id_Budzet ID budzetu z ktorego chcemy usunąć wydatek
   * @param id_wydatek ID wydatku
   */
  public void usunBudzetWydatek(int id_Budzet,int id_wydatek){
      String query = "DELETE FROM budzetwydatek WHERE id_Budzet="+id_Budzet+" and id_wydatek="+id_wydatek;

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
  }

   /**
   * Funkcja dodaje rekort do tabeli "BUDZETPRZYCHOD"
   *
   * @param id_Budzet ID budzetu do ktorego chcemy dodać przychod
   * @param id_przychod ID przychodu
   */
  public void dodajBudzetPrzychod(int id_Budzet,int id_przychod){
      String query = "INSERT INTO budzetprzychod(id_budzet,id_przychod) VALUES("+id_Budzet+","+id_przychod+")";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
  }

   /**
   * Funkcja usuwa rekort z tabeli "BUDZETWYDATEK"
   *
   * @param id_Budzet ID budzetu z ktorego chcemy usunąć przychod
   * @param id_przychod ID przychod
   */
  public void usunBudzetPrzychod(int id_Budzet,int id_przychod){
       String query = "DELETE FROM budzetprzychod WHERE id_Budzet="+id_Budzet+" and id_przychod="+id_przychod;

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
  }
  /**
   * Funkcja dodaje kategorie do tabeli "KATPRZYCHOD"
   *
   * @param nazwa Nazwa kategorii
   * @return Funkcja zwraca wartość TRUE w przypadku gdy doda wpis do bazy, FALSE gdy go niedoda np. gdy wpis juz istnieje
   */


  public Boolean dodajKategoriePrzychodu(String nazwa){
      //zapytanie sprawdzające czy dana nazwa kategorii juz występuje w bazie
        String query = "SELECT count(*) as liczba from katprzychod where nazwa='"+nazwa+"'";

        try{
            statemnet = connection.createStatement();
            rs = statemnet.executeQuery(query);
            String liczba="";

            while(rs.next()){
                liczba =  rs.getString("liczba");
            }
            //jezeli nazwa kategorii juz występuje juz występuje w bazie
            if(!liczba.equals("0"))
                return false;
            else{
                query = "INSERT INTO katprzychod(nazwa) VALUE('"+nazwa+"')";
                statemnet.executeUpdate(query);
            }
        }catch (SQLException e) {
            System.err.println("Bład "+e);
        }
        return true;
  }

  /**
   * Funkcja usuwająca z tabeli "KATPRZYCHOD" kategorie wydatku
   *
   * @param nazwa Nazwa kategorii do usuniecia
   */

  public void usunKategoriePrzychodu(String nazwa){
      String query = "DELETE FROM katprzychod where nazwa='"+nazwa+"'";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
  }
/**
 * Funkcja edytuje nazwę kategorii przychodu
 * 
 * @param staraN Stara nazwa kategorii
 * @param nowaN  Nowa nazwa kategorii
 * @return
 */
  public Boolean edytujKategoriePrzychodu(String staraN,String nowaN){
      String query = "UPDATE katprzychod SET nazwa='"+nowaN+"' WHERE nazwa='"+staraN+"'";

      try{
          statemnet = connection.createStatement();
          statemnet.executeUpdate(query);
      }catch(SQLException e){
          System.err.println("Bład: "+e);
      }
      return true;
  }

  /**
 * Funkcja dodaje wydatek do tabeli "PRZYCHOD" i zwraca ID wstawionego wiersza
 * @param nazwa Nazwa przychodu
 * @param idKatPrzychod id kategori przychodu np. hazard
 * @param wartosc wartość double przychodu np. 9.99
   @param data Data przychodu
 * @return funkcja zwraca ID rekordu nowo wstawionego wiersza przez instrukcje INSERT czyli ID wydatku
 */
  public int dodajPrzychod(String nazwa,int idKatPrzychod,double wartosc,String data){

        String query = "INSERT INTO przychod(nazwa,id_kat_przychod,data_przychod,wartosc)"
                + " VALUE('"+nazwa+"',"+idKatPrzychod+",'"+data+"',"+wartosc+")";
        int id_wydatek=0;
        try{
            statemnet = connection.createStatement();
            statemnet.executeUpdate(query);

            //pobieranie ID ostatnio wstawionego rekordu
                query = "SELECT last_insert_id() as ID from przychod";
                rs = statemnet.executeQuery(query);

                while(rs.next()){
                    id_wydatek = rs.getInt("ID");
                }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }

        return id_wydatek;
    }
  /**
   * Funkcja usuwająca wydatek z tabeli "PRZYCHOD"
   *
   * @param id_wydatek ID wydatku, który chcemy usunąć
   */
 public void usunPrzychod(int id_przychod){
     String query = "DELETE FROM wydatek WHERE id_wydatke="+id_przychod;

      try{
           statemnet = connection.createStatement();
           statemnet.executeUpdate(query);
       }catch(SQLException e){
           System.err.println("Błąd: "+e);
       }
 }

 /**
  * Funkcja zwraca ID z kategorii z tabeli "KATPRZYCHOD"
  *
  * @param nazwaKategorii Nazwa kategori której ID chcemy otrzymać
  * @return ID kategorii
  */
 public int idKatPrzychod(String nazwaKategorii){
     String query = "SELECT id_kat_przychod as ID FROM katprzychod WHERE nazwa='"+nazwaKategorii+"'";

     int ID=0;
      try{
            statemnet = connection.createStatement();            
            rs = statemnet.executeQuery(query);

                while(rs.next()){
                    ID = rs.getInt("ID");
                }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }
     return ID;
 }

 /**
  * Funkcja zwraca ID z kategorii z tabeli "KATWYDATEK"
  *
  * @param nazwaKategorii Nazwa kategori której ID chcemy otrzymać
  * @return ID kategorii
  */

 public int idKatWydatek(String nazwaKategorii){
     String query = "SELECT id_kat_wydatek as ID FROM katwydatek WHERE nazwa='"+nazwaKategorii+"'";

     int ID=0;
      try{
            statemnet = connection.createStatement();            
            rs = statemnet.executeQuery(query);

                while(rs.next()){
                    ID = rs.getInt("ID");
                }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }
     return ID;
 }

 public int idSklep(String nazwaKategorii){
     String query = "SELECT id_sklep as ID FROM sklep WHERE nazwa='"+nazwaKategorii+"'";

     int ID=0;
      try{
            statemnet = connection.createStatement();            
            rs = statemnet.executeQuery(query);

                while(rs.next()){
                    ID = rs.getInt("ID");
                }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }
     return ID;
 }

 public int idKatProdukt (String nazwaKategorii){
     String query = "SELECT id_kat_produkt as ID FROM katprodukt WHERE nazwa='"+nazwaKategorii+"'";

     int ID=0;
      try{
            statemnet = connection.createStatement();            
            rs = statemnet.executeQuery(query);

                while(rs.next()){
                    ID = rs.getInt("ID");
                }

        }catch(SQLException e){
            System.err.println("Bład: "+e);
        }
     return ID;
 }

public LinkedList<Entry> pobierzPrzychody(int idBudzet){
    String query = "select prz.nazwa as 'Nazwa',prz.data_przychod as 'Data',prz.wartosc as 'Wartosc', katp.nazwa as 'Kategoria przychodu'"
            +" from przychod prz,katprzychod katp,budzetprzychod bp,budzet b"
            +" where katp.id_kat_przychod= prz.id_kat_przychod "
            + "and prz.id_przychod=bp.id_przychod and bp.id_budzet=b.id_budzet and b.id_budzet="+idBudzet;
    LinkedList<Entry> wynik =  new LinkedList<Entry>();
     try{
        statemnet = connection.createStatement();
        rs = statemnet.executeQuery(query);
        Entry tmp;
                while(rs.next()){
                    tmp = new Entry();
                    tmp.setName(rs.getString("Nazwa"));
                    tmp.setDate(rs.getDate("Data"));
                    tmp.setWartosc(rs.getDouble("Wartosc"));
                    tmp.setCategory(rs.getString("Kategoria przychodu"));
                  
                    wynik.add(tmp);
                }

    }catch(SQLException e){
        System.err.println("Bład: "+e);
    }
    return wynik;

}

public LinkedList<Entry> pobierzWydatki(int idBudzet){
    String query = "select wyd.nazwa as 'Nazwa wydatku',wyd.data_wydatek as 'Data', wyd.wartosc as 'Wartosc', katw.nazwa as 'Kategoria wydatku',"
            +" pro.nazwa as 'Nazwa Produktu',katp.nazwa as 'Kategoria produktu', pro.cena as 'Cena',wp.ilosc as 'Ilosc', sk.nazwa as 'Sklep'"
            +" from budzetwydatek bw,budzet b,wydatek wyd,produkt pro,wydatek_produkt wp,katwydatek katw,sklep sk,katprodukt katp"
            +" where wp.id_wydatek = wyd.id_wydatek and wp.id_produkt = pro.id_produkt and katw.id_kat_wydatek = wyd.id_kat_wydatek"
            +" and sk.id_sklep = pro.id_sklep and katp.id_kat_produkt = pro.id_kat_produkt "
            + "and wyd.id_wydatek = bw.id_wydatek and bw.id_budzet = b.id_budzet and b.id_budzet="+idBudzet;

    LinkedList<Entry> wynik = new LinkedList<Entry>();
    
    try{
        statemnet = connection.createStatement();
        rs = statemnet.executeQuery(query);
        Entry tmp;
                while(rs.next()){
                    tmp = new Entry();
                    tmp.setName(rs.getString("Nazwa wydatku"));
                    tmp.setDate(rs.getDate("Data"));
                    tmp.setWartosc(rs.getDouble("Wartosc"));
                    tmp.setCategory(rs.getString("Kategoria wydatku"));
                    tmp.setNameProduct(rs.getString("Nazwa Produktu"));
                    tmp.setCategoryProduct(rs.getString("Kategoria produktu"));
                    tmp.setPrice(rs.getDouble("Cena"));
                    tmp.setShop(rs.getString("Sklep"));
                    tmp.setQuantity(rs.getDouble("Ilosc"));
                    wynik.add(tmp);                   
                }

    }catch(SQLException e){
        System.err.println("Bład: "+e);
    }
    return wynik;
    }
}
